// Access the version of OpString
console.log(opString.version);

// Output: '0.5.1'

// Create an empty OpString instance
const opString = new OpString();

// Create an OpString instance and enable `strictMode`
const opString = new OpString({
    strictMode: true, // (default: false)
});

// Create a new instance and configure it with initial settings
const opString = new OpString({
    sequence: 'AaabBabcc',
    operations: {
        'A': (x, y, d) => { console.log(x, y, d); },
        'B': (x, y, w, h) => { console.log(x, y, w, h); },
    },
    values: {
        'a': 30,
        'b': 20,
        'c': 55,
    },
    labels: {
        'circle': 'A',
        'rect': 'B',
    },
    maxSequenceLength: 10,
    ignoreWarnings: false, // (default: false)
    strictMode: true, // (default: false)
});

// Get the next operation id
const nextId = opString.getNextId();

// Example output: 3

// Append an operation to the sequence and return its id
const operationId = opString.append('V');

// Specify the values to be passed to the operation. This will append 'Aaab' to the sequence.
opString.append('A', ['a', 'a', 'b']);

/**
 * Alternatively, you can use character codes instead of characters (e.g. 'A'.charCodeAt(0) => 65).
 * This will also append 'Aaab' to the sequence.
 */
opString.append(65, [97, 97, 98]);

/**
 * Insert an operation at index 2 of the operations to be executed and returns 
 * its id. The operation will be the third one to be executed.
 */
const operationId = opString.insert(2, 'V');

/**
 * Specify the values to be passed to the operation.
 * 
 * The following example inserts the operation 'Aaab' at index 2 of the
 * operations to be executed, making it the third operation to be executed.
 */
opString.insert(2, 'A', ['a', 'a', 'b']);

/**
 * Alternatively, you can use character codes instead of characters (e.g. 'A'.charCodeAt(0) => 65).
 * This will also insert 'Aaab' at index 2 of the sequence.
 */
opString.insert(2, 65, [97, 97, 98]);

// Prepend an operation to the sequence and return its id
const operationId = opString.prepend('V');

// Specify the values to be passed to the operation. This will prepend 'Aaab' to the sequence.
opString.prepend('A', ['a', 'a', 'b']);

/**
 * Alternatively, you can use character codes instead of characters (e.g. 'A'.charCodeAt(0) => 65).
 * This will also prepend 'Aaab' to the sequence.
 */
opString.prepend(65, [97, 97, 98]);

// Remove operation with id 3 from the sequence
const removed = opString.remove(3);

// Get the index of operation with id 3 in the sequence
const operationIndex = opString.index(3);

// Set the character sequence
opString.setSequence('AaabBabcc');

/**
 * Handling an unknown value character
 *
 * Suppose the sequence is 'Ba?c'. The '?' represents an unknown value character.
 * In this case, the unknown character will be registered with a value of `null`.
 * By registering it this way, the associated operation can still be executed.
 */
opString.setSequence('Ba?c');

// Get the character sequence
const sequence = opString.getSequence();

// Example output: 'AaabBabcc'

// Get the sequence data array
const sequenceData = opString.getSequenceData();

// Example output for sequence 'AaabBabcc':
// [
//   { id: 1, operation: 65, values: [ 97, 97, 98 ] },
//   { id: 2, operation: 66, values: [ 97, 98, 99, 99 ] }
// ]

// Register an operation mapping
opString.registerOperation('X', () => console.log('Operation X'));

// Register an operation mapping using character code
opString.registerOperation(88, () => console.log('Operation X'));

// Register additional operation mappings
opString.registerOperations({
    'D': () => { /*...*/ },
    'E': () => { /*...*/ },
    'F': () => { /*...*/ },
});

// Register additional operation mappings using chracter codes
opString.registerOperations({
    68: () => { /*...*/ },
    69: () => { /*...*/ },
    70: () => { /*...*/ },
});

// Set new operation mappings
opString.setOperations({
    'A': () => { /*...*/ },
    'B': () => { /*...*/ },
    'C': () => { /*...*/ },
});

// Get the registered operations
const operations = opString.getOperations();

// Example output:
// { '65': [Function: A], '66': [Function: B] }

// Register a value mapping
opString.registerValue('x', 10);

// Register a value mapping using character code
opString.registerValue(120, 10);

// Register additional value mappings
opString.registerValues({
    'x': 10,
    'y': 11,
    'z': 12,
});

// Alternatively, you can register additional value mappings using character codes
opString.registerValues({
    120: 10,
    121: 11,
    122: 12,
});

// Set new value mappings
opString.setValues({
    'a': 1,
    'b': 2,
    'c': 3,
});

// Alternatively, you can set new value mappings using character codes
opString.setValues({
    97: 1,
    98: 2,
    99: 3,
});

// Get the registered values
const values = opString.getValues();

// Example output:
// { '97': 30, '98': 20, '99': 55 }

// Get the corresponding character for the provided value
const char = opString.getCharCodeForValue(55);

// Example output: 'c'

// Get the corresponding charCode for the provided value
const charCode = opString.getCharCodeForValue(55);

// Example output: 99

// Register a label mapping
opString.registerLabel('circle', 'A');

// Register a label mapping using character code
opString.registerLabel('circle', 65);

// Register additional label mappings
opString.registerLabels({
    'circle': 'A',
    'rect': 'B',
    'ten': 'x',
});

// Alternatively, you can register additional label mappings using character codes
opString.registerLabels({
    'circle': 65,
    'rect': 66,
    'ten': 120,
});

// Set new label mappings
opString.setLabels({
    'circle': 'A',
    'rect': 'B',
    'ten': 'x',
});

// Alternatively, you can set new label mappings using character codes
opString.setLabels({
    'circle': 65,
    'rect': 66,
    'ten': 120,
});

// Get the registered labels
const labels = opString.getLabels();

// Example output:
// { 'circle': 65, 'rect': 66, 'ten': 120 }

// Get the corresponding character for the provided label
const char = opString.getCharCodeForLabel('circle');

// Example output: 'A'

// Get the corresponding charCode for the provided label
const charCode = opString.getCharCodeForLabel('circle');

// Example output: 65

// Set the maximum sequence length to 100
opString.setMaxSequenceLength(100);

// Get the max sequence length
const maxSequenceLength = opString.getMaxSequenceLength();

// Example output, if configured: 100

// Output, if not configured: undefined

// Execute the character sequence of the current instance
opString.execute();

// Execute a provided character sequence
opString.execute('XxxyYxyzz');