@kubb/agent 5.0.0-alpha.36 → 5.0.0-alpha.38

package/.output/server/node_modules/json-schema-merge-allof/src/index.js

@@ -1,343 +0,0 @@
-const cloneDeep = require('lodash/cloneDeep')
-const compare = require('json-schema-compare')
-const computeLcm = require('compute-lcm')
-const defaultsDeep = require('lodash/defaultsDeep')
-const flatten = require('lodash/flatten')
-const flattenDeep = require('lodash/flattenDeep')
-const intersection = require('lodash/intersection')
-const intersectionWith = require('lodash/intersectionWith')
-const isEqual = require('lodash/isEqual')
-const isPlainObject = require('lodash/isPlainObject')
-const pullAll = require('lodash/pullAll')
-const sortBy = require('lodash/sortBy')
-const uniq = require('lodash/uniq')
-const uniqWith = require('lodash/uniqWith')
-
-const propertiesResolver = require('./complex-resolvers/properties')
-const itemsResolver = require('./complex-resolvers/items')
-
-const contains = (arr, val) => arr.indexOf(val) !== -1
-const isSchema = (val) => isPlainObject(val) || val === true || val === false
-const isFalse = (val) => val === false
-const isTrue = (val) => val === true
-const schemaResolver = (compacted, key, mergeSchemas) => mergeSchemas(compacted)
-const stringArray = (values) => sortBy(uniq(flattenDeep(values)))
-const notUndefined = (val) => val !== undefined
-const allUniqueKeys = (arr) => uniq(flattenDeep(arr.map(keys)))
-
-// resolvers
-const first = compacted => compacted[0]
-const required = compacted => stringArray(compacted)
-const maximumValue = compacted => Math.max.apply(Math, compacted)
-const minimumValue = compacted => Math.min.apply(Math, compacted)
-const uniqueItems = compacted => compacted.some(isTrue)
-const examples = compacted => uniqWith(flatten(compacted), isEqual)
-
-function compareProp(key) {
-  return function(a, b) {
-    return compare({
-      [key]: a
-    }, { [key]: b })
-  }
-}
-
-function getAllOf(schema) {
-  let { allOf = [], ...copy } = schema
-  copy = isPlainObject(schema) ? copy : schema // if schema is boolean
-  return [copy, ...allOf.map(getAllOf)]
-}
-
-function getValues(schemas, key) {
-  return schemas.map(schema => schema && schema[key])
-}
-
-function tryMergeSchemaGroups(schemaGroups, mergeSchemas) {
-  return schemaGroups.map(function(schemas, index) {
-    try {
-      return mergeSchemas(schemas, index)
-    } catch (e) {
-      return undefined
-    }
-  }).filter(notUndefined)
-}
-
-function keys(obj) {
-  if (isPlainObject(obj) || Array.isArray(obj)) {
-    return Object.keys(obj)
-  } else {
-    return []
-  }
-}
-
-function getAnyOfCombinations(arrOfArrays, combinations) {
-  combinations = combinations || []
-  if (!arrOfArrays.length) {
-    return combinations
-  }
-
-  const values = arrOfArrays.slice(0).shift()
-  const rest = arrOfArrays.slice(1)
-  if (combinations.length) {
-    return getAnyOfCombinations(rest, flatten(combinations.map(combination => values.map(item => ([item].concat(combination))))))
-  }
-  return getAnyOfCombinations(rest, values.map(item => (item)))
-}
-
-function throwIncompatible(values, paths) {
-  let asJSON
-  try {
-    asJSON = values.map(function(val) {
-      return JSON.stringify(val, null, 2)
-    }).join('\n')
-  } catch (variable) {
-    asJSON = values.join(', ')
-  }
-  throw new Error('Could not resolve values for path:"' + paths.join('.') + '". They are probably incompatible. Values: \n' + asJSON)
-}
-
-function callGroupResolver(complexKeywords, resolverName, schemas, mergeSchemas, options, parents) {
-  if (complexKeywords.length) {
-    const resolverConfig = options.complexResolvers[resolverName]
-    if (!resolverConfig || !resolverConfig.resolver) {
-      throw new Error('No resolver found for ' + resolverName)
-    }
-
-    // extract all keywords from all the schemas that have one or more
-    // then remove all undefined ones and not unique
-    const extractedKeywordsOnly = schemas.map(schema => complexKeywords.reduce((all, key) => {
-      if (schema[key] !== undefined) all[key] = schema[key]
-      return all
-    }, {}))
-    const unique = uniqWith(extractedKeywordsOnly, compare)
-
-    // create mergers that automatically add the path of the keyword for use in the complex resolver
-    const mergers = resolverConfig.keywords.reduce((all, key) => ({
-      ...all,
-      [key]: (schemas, extraKey = []) => mergeSchemas(schemas, null, parents.concat(key, extraKey))
-    }), {})
-
-    const result = resolverConfig.resolver(unique, parents.concat(resolverName), mergers, options)
-
-    if (!isPlainObject(result)) {
-      throwIncompatible(unique, parents.concat(resolverName))
-    }
-
-    return result
-  }
-}
-
-function createRequiredMetaArray(arr) {
-  return { required: arr }
-}
-
-const schemaGroupProps = ['properties', 'patternProperties', 'definitions', 'dependencies']
-const schemaArrays = ['anyOf', 'oneOf']
-const schemaProps = [
-  'additionalProperties',
-  'additionalItems',
-  'contains',
-  'propertyNames',
-  'not',
-  'items'
-]
-
-const defaultResolvers = {
-  type(compacted) {
-    if (compacted.some(Array.isArray)) {
-      const normalized = compacted.map(function(val) {
-        return Array.isArray(val)
-          ? val
-          : [val]
-      })
-      const common = intersection.apply(null, normalized)
-
-      if (common.length === 1) {
-        return common[0]
-      } else if (common.length > 1) {
-        return uniq(common)
-      }
-    }
-  },
-  dependencies(compacted, paths, mergeSchemas) {
-    const allChildren = allUniqueKeys(compacted)
-
-    return allChildren.reduce(function(all, childKey) {
-      const childSchemas = getValues(compacted, childKey)
-      let innerCompacted = uniqWith(childSchemas.filter(notUndefined), isEqual)
-
-      // to support dependencies
-      const innerArrays = innerCompacted.filter(Array.isArray)
-
-      if (innerArrays.length) {
-        if (innerArrays.length === innerCompacted.length) {
-          all[childKey] = stringArray(innerCompacted)
-        } else {
-          const innerSchemas = innerCompacted.filter(isSchema)
-          const arrayMetaScheams = innerArrays.map(createRequiredMetaArray)
-          all[childKey] = mergeSchemas(innerSchemas.concat(arrayMetaScheams), childKey)
-        }
-        return all
-      }
-
-      innerCompacted = uniqWith(innerCompacted, compare)
-
-      all[childKey] = mergeSchemas(innerCompacted, childKey)
-      return all
-    }, {})
-  },
-  oneOf(compacted, paths, mergeSchemas) {
-    const combinations = getAnyOfCombinations(cloneDeep(compacted))
-    const result = tryMergeSchemaGroups(combinations, mergeSchemas)
-    const unique = uniqWith(result, compare)
-
-    if (unique.length) {
-      return unique
-    }
-  },
-  not(compacted) {
-    return { anyOf: compacted }
-  },
-  pattern(compacted) {
-    return compacted.map(r => '(?=' + r + ')').join('')
-  },
-  multipleOf(compacted) {
-    let integers = compacted.slice(0)
-    let factor = 1
-    while (integers.some(n => !Number.isInteger(n))) {
-      integers = integers.map(n => n * 10)
-      factor = factor * 10
-    }
-    return computeLcm(integers) / factor
-  },
-  enum(compacted) {
-    const enums = intersectionWith.apply(null, compacted.concat(isEqual))
-    if (enums.length) {
-      return sortBy(enums)
-    }
-  }
-}
-
-defaultResolvers.$id = first
-defaultResolvers.$ref = first
-defaultResolvers.$schema = first
-defaultResolvers.additionalItems = schemaResolver
-defaultResolvers.additionalProperties = schemaResolver
-defaultResolvers.anyOf = defaultResolvers.oneOf
-defaultResolvers.contains = schemaResolver
-defaultResolvers.default = first
-defaultResolvers.definitions = defaultResolvers.dependencies
-defaultResolvers.description = first
-defaultResolvers.examples = examples
-defaultResolvers.exclusiveMaximum = minimumValue
-defaultResolvers.exclusiveMinimum = maximumValue
-defaultResolvers.items = itemsResolver
-defaultResolvers.maximum = minimumValue
-defaultResolvers.maxItems = minimumValue
-defaultResolvers.maxLength = minimumValue
-defaultResolvers.maxProperties = minimumValue
-defaultResolvers.minimum = maximumValue
-defaultResolvers.minItems = maximumValue
-defaultResolvers.minLength = maximumValue
-defaultResolvers.minProperties = maximumValue
-defaultResolvers.properties = propertiesResolver
-defaultResolvers.propertyNames = schemaResolver
-defaultResolvers.required = required
-defaultResolvers.title = first
-defaultResolvers.uniqueItems = uniqueItems
-
-const defaultComplexResolvers = {
-  properties: propertiesResolver,
-  items: itemsResolver
-}
-
-function merger(rootSchema, options, totalSchemas) {
-  totalSchemas = totalSchemas || []
-  options = defaultsDeep(options, {
-    ignoreAdditionalProperties: false,
-    resolvers: defaultResolvers,
-    complexResolvers: defaultComplexResolvers,
-    deep: true
-  })
-
-  const complexResolvers = Object.entries(options.complexResolvers)
-
-  function mergeSchemas(schemas, base, parents) {
-    schemas = cloneDeep(schemas.filter(notUndefined))
-    parents = parents || []
-    const merged = isPlainObject(base)
-      ? base
-      : {}
-
-    // return undefined, an empty schema
-    if (!schemas.length) {
-      return
-    }
-
-    if (schemas.some(isFalse)) {
-      return false
-    }
-
-    if (schemas.every(isTrue)) {
-      return true
-    }
-
-    // there are no false and we don't need the true ones as they accept everything
-    schemas = schemas.filter(isPlainObject)
-
-    const allKeys = allUniqueKeys(schemas)
-    if (options.deep && contains(allKeys, 'allOf')) {
-      return merger({
-        allOf: schemas
-      }, options, totalSchemas)
-    }
-
-    const complexKeysArr = complexResolvers.map(([mainKeyWord, resolverConf]) =>
-      allKeys.filter(k => resolverConf.keywords.includes(k)))
-
-    // remove all complex keys before simple resolvers
-    complexKeysArr.forEach(keys => pullAll(allKeys, keys))
-
-    // call all simple resolvers for relevant keywords
-    allKeys.forEach(function(key) {
-      const values = getValues(schemas, key)
-      const compacted = uniqWith(values.filter(notUndefined), compareProp(key))
-
-      // arrayprops like anyOf and oneOf must be merged first, as they contains schemas
-      // allOf is treated differently alltogether
-      if (compacted.length === 1 && contains(schemaArrays, key)) {
-        merged[key] = compacted[0].map(schema => mergeSchemas([schema], schema))
-        // prop groups must always be resolved
-      } else if (compacted.length === 1 && !contains(schemaGroupProps, key) && !contains(schemaProps, key)) {
-        merged[key] = compacted[0]
-      } else {
-        const resolver = options.resolvers[key] || options.resolvers.defaultResolver
-        if (!resolver) throw new Error('No resolver found for key ' + key + '. You can provide a resolver for this keyword in the options, or provide a default resolver.')
-
-        const merger = (schemas, extraKey = []) => mergeSchemas(schemas, null, parents.concat(key, extraKey))
-        merged[key] = resolver(compacted, parents.concat(key), merger, options)
-
-        if (merged[key] === undefined) {
-          throwIncompatible(compacted, parents.concat(key))
-        } else if (merged[key] === undefined) {
-          delete merged[key]
-        }
-      }
-    })
-
-    return complexResolvers.reduce((all, [resolverKeyword, config], index) => ({
-      ...all,
-      ...callGroupResolver(complexKeysArr[index], resolverKeyword, schemas, mergeSchemas, options, parents)
-    }), merged)
-  }
-
-  const allSchemas = flattenDeep(getAllOf(rootSchema))
-  const merged = mergeSchemas(allSchemas)
-
-  return merged
-}
-
-merger.options = {
-  resolvers: defaultResolvers
-}
-
-module.exports = merger

package/.output/server/node_modules/json-schema-traverse/index.js

@@ -1,93 +0,0 @@
-'use strict';
-
-var traverse = module.exports = function (schema, opts, cb) {
-  // Legacy support for v0.3.1 and earlier.
-  if (typeof opts == 'function') {
-    cb = opts;
-    opts = {};
-  }
-
-  cb = opts.cb || cb;
-  var pre = (typeof cb == 'function') ? cb : cb.pre || function() {};
-  var post = cb.post || function() {};
-
-  _traverse(opts, pre, post, schema, '', schema);
-};
-
-
-traverse.keywords = {
-  additionalItems: true,
-  items: true,
-  contains: true,
-  additionalProperties: true,
-  propertyNames: true,
-  not: true,
-  if: true,
-  then: true,
-  else: true
-};
-
-traverse.arrayKeywords = {
-  items: true,
-  allOf: true,
-  anyOf: true,
-  oneOf: true
-};
-
-traverse.propsKeywords = {
-  $defs: true,
-  definitions: true,
-  properties: true,
-  patternProperties: true,
-  dependencies: true
-};
-
-traverse.skipKeywords = {
-  default: true,
-  enum: true,
-  const: true,
-  required: true,
-  maximum: true,
-  minimum: true,
-  exclusiveMaximum: true,
-  exclusiveMinimum: true,
-  multipleOf: true,
-  maxLength: true,
-  minLength: true,
-  pattern: true,
-  format: true,
-  maxItems: true,
-  minItems: true,
-  uniqueItems: true,
-  maxProperties: true,
-  minProperties: true
-};
-
-
-function _traverse(opts, pre, post, schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex) {
-  if (schema && typeof schema == 'object' && !Array.isArray(schema)) {
-    pre(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
-    for (var key in schema) {
-      var sch = schema[key];
-      if (Array.isArray(sch)) {
-        if (key in traverse.arrayKeywords) {
-          for (var i=0; i<sch.length; i++)
-            _traverse(opts, pre, post, sch[i], jsonPtr + '/' + key + '/' + i, rootSchema, jsonPtr, key, schema, i);
-        }
-      } else if (key in traverse.propsKeywords) {
-        if (sch && typeof sch == 'object') {
-          for (var prop in sch)
-            _traverse(opts, pre, post, sch[prop], jsonPtr + '/' + key + '/' + escapeJsonPtr(prop), rootSchema, jsonPtr, key, schema, prop);
-        }
-      } else if (key in traverse.keywords || (opts.allKeys && !(key in traverse.skipKeywords))) {
-        _traverse(opts, pre, post, sch, jsonPtr + '/' + key, rootSchema, jsonPtr, key, schema);
-      }
-    }
-    post(schema, jsonPtr, rootSchema, parentJsonPtr, parentKeyword, parentSchema, keyIndex);
-  }
-}
-
-
-function escapeJsonPtr(str) {
-  return str.replace(/~/g, '~0').replace(/\//g, '~1');
-}

package/.output/server/node_modules/json-schema-traverse/package.json

@@ -1,43 +0,0 @@
-{
-  "name": "json-schema-traverse",
-  "version": "1.0.0",
-  "description": "Traverse JSON Schema passing each schema object to callback",
-  "main": "index.js",
-  "types": "index.d.ts",
-  "scripts": {
-    "eslint": "eslint index.js spec",
-    "test-spec": "mocha spec -R spec",
-    "test": "npm run eslint && nyc npm run test-spec"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/epoberezkin/json-schema-traverse.git"
-  },
-  "keywords": [
-    "JSON-Schema",
-    "traverse",
-    "iterate"
-  ],
-  "author": "Evgeny Poberezkin",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/epoberezkin/json-schema-traverse/issues"
-  },
-  "homepage": "https://github.com/epoberezkin/json-schema-traverse#readme",
-  "devDependencies": {
-    "eslint": "^7.3.1",
-    "mocha": "^8.0.1",
-    "nyc": "^15.0.0",
-    "pre-commit": "^1.2.2"
-  },
-  "nyc": {
-    "exclude": [
-      "**/spec/**",
-      "node_modules"
-    ],
-    "reporter": [
-      "lcov",
-      "text-summary"
-    ]
-  }
-}

package/.output/server/node_modules/jsonc-parser/lib/umd/impl/edit.js

@@ -1,201 +0,0 @@
-(function (factory) {
-    if (typeof module === "object" && typeof module.exports === "object") {
-        var v = factory(require, exports);
-        if (v !== undefined) module.exports = v;
-    }
-    else if (typeof define === "function" && define.amd) {
-        define(["require", "exports", "./format", "./parser"], factory);
-    }
-})(function (require, exports) {
-    /*---------------------------------------------------------------------------------------------
-     *  Copyright (c) Microsoft Corporation. All rights reserved.
-     *  Licensed under the MIT License. See License.txt in the project root for license information.
-     *--------------------------------------------------------------------------------------------*/
-    'use strict';
-    Object.defineProperty(exports, "__esModule", { value: true });
-    exports.isWS = exports.applyEdit = exports.setProperty = exports.removeProperty = void 0;
-    const format_1 = require("./format");
-    const parser_1 = require("./parser");
-    function removeProperty(text, path, options) {
-        return setProperty(text, path, void 0, options);
-    }
-    exports.removeProperty = removeProperty;
-    function setProperty(text, originalPath, value, options) {
-        const path = originalPath.slice();
-        const errors = [];
-        const root = (0, parser_1.parseTree)(text, errors);
-        let parent = void 0;
-        let lastSegment = void 0;
-        while (path.length > 0) {
-            lastSegment = path.pop();
-            parent = (0, parser_1.findNodeAtLocation)(root, path);
-            if (parent === void 0 && value !== void 0) {
-                if (typeof lastSegment === 'string') {
-                    value = { [lastSegment]: value };
-                }
-                else {
-                    value = [value];
-                }
-            }
-            else {
-                break;
-            }
-        }
-        if (!parent) {
-            // empty document
-            if (value === void 0) { // delete
-                throw new Error('Can not delete in empty document');
-            }
-            return withFormatting(text, { offset: root ? root.offset : 0, length: root ? root.length : 0, content: JSON.stringify(value) }, options);
-        }
-        else if (parent.type === 'object' && typeof lastSegment === 'string' && Array.isArray(parent.children)) {
-            const existing = (0, parser_1.findNodeAtLocation)(parent, [lastSegment]);
-            if (existing !== void 0) {
-                if (value === void 0) { // delete
-                    if (!existing.parent) {
-                        throw new Error('Malformed AST');
-                    }
-                    const propertyIndex = parent.children.indexOf(existing.parent);
-                    let removeBegin;
-                    let removeEnd = existing.parent.offset + existing.parent.length;
-                    if (propertyIndex > 0) {
-                        // remove the comma of the previous node
-                        let previous = parent.children[propertyIndex - 1];
-                        removeBegin = previous.offset + previous.length;
-                    }
-                    else {
-                        removeBegin = parent.offset + 1;
-                        if (parent.children.length > 1) {
-                            // remove the comma of the next node
-                            let next = parent.children[1];
-                            removeEnd = next.offset;
-                        }
-                    }
-                    return withFormatting(text, { offset: removeBegin, length: removeEnd - removeBegin, content: '' }, options);
-                }
-                else {
-                    // set value of existing property
-                    return withFormatting(text, { offset: existing.offset, length: existing.length, content: JSON.stringify(value) }, options);
-                }
-            }
-            else {
-                if (value === void 0) { // delete
-                    return []; // property does not exist, nothing to do
-                }
-                const newProperty = `${JSON.stringify(lastSegment)}: ${JSON.stringify(value)}`;
-                const index = options.getInsertionIndex ? options.getInsertionIndex(parent.children.map(p => p.children[0].value)) : parent.children.length;
-                let edit;
-                if (index > 0) {
-                    let previous = parent.children[index - 1];
-                    edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };
-                }
-                else if (parent.children.length === 0) {
-                    edit = { offset: parent.offset + 1, length: 0, content: newProperty };
-                }
-                else {
-                    edit = { offset: parent.offset + 1, length: 0, content: newProperty + ',' };
-                }
-                return withFormatting(text, edit, options);
-            }
-        }
-        else if (parent.type === 'array' && typeof lastSegment === 'number' && Array.isArray(parent.children)) {
-            const insertIndex = lastSegment;
-            if (insertIndex === -1) {
-                // Insert
-                const newProperty = `${JSON.stringify(value)}`;
-                let edit;
-                if (parent.children.length === 0) {
-                    edit = { offset: parent.offset + 1, length: 0, content: newProperty };
-                }
-                else {
-                    const previous = parent.children[parent.children.length - 1];
-                    edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };
-                }
-                return withFormatting(text, edit, options);
-            }
-            else if (value === void 0 && parent.children.length >= 0) {
-                // Removal
-                const removalIndex = lastSegment;
-                const toRemove = parent.children[removalIndex];
-                let edit;
-                if (parent.children.length === 1) {
-                    // only item
-                    edit = { offset: parent.offset + 1, length: parent.length - 2, content: '' };
-                }
-                else if (parent.children.length - 1 === removalIndex) {
-                    // last item
-                    let previous = parent.children[removalIndex - 1];
-                    let offset = previous.offset + previous.length;
-                    let parentEndOffset = parent.offset + parent.length;
-                    edit = { offset, length: parentEndOffset - 2 - offset, content: '' };
-                }
-                else {
-                    edit = { offset: toRemove.offset, length: parent.children[removalIndex + 1].offset - toRemove.offset, content: '' };
-                }
-                return withFormatting(text, edit, options);
-            }
-            else if (value !== void 0) {
-                let edit;
-                const newProperty = `${JSON.stringify(value)}`;
-                if (!options.isArrayInsertion && parent.children.length > lastSegment) {
-                    const toModify = parent.children[lastSegment];
-                    edit = { offset: toModify.offset, length: toModify.length, content: newProperty };
-                }
-                else if (parent.children.length === 0 || lastSegment === 0) {
-                    edit = { offset: parent.offset + 1, length: 0, content: parent.children.length === 0 ? newProperty : newProperty + ',' };
-                }
-                else {
-                    const index = lastSegment > parent.children.length ? parent.children.length : lastSegment;
-                    const previous = parent.children[index - 1];
-                    edit = { offset: previous.offset + previous.length, length: 0, content: ',' + newProperty };
-                }
-                return withFormatting(text, edit, options);
-            }
-            else {
-                throw new Error(`Can not ${value === void 0 ? 'remove' : (options.isArrayInsertion ? 'insert' : 'modify')} Array index ${insertIndex} as length is not sufficient`);
-            }
-        }
-        else {
-            throw new Error(`Can not add ${typeof lastSegment !== 'number' ? 'index' : 'property'} to parent of type ${parent.type}`);
-        }
-    }
-    exports.setProperty = setProperty;
-    function withFormatting(text, edit, options) {
-        if (!options.formattingOptions) {
-            return [edit];
-        }
-        // apply the edit
-        let newText = applyEdit(text, edit);
-        // format the new text
-        let begin = edit.offset;
-        let end = edit.offset + edit.content.length;
-        if (edit.length === 0 || edit.content.length === 0) { // insert or remove
-            while (begin > 0 && !(0, format_1.isEOL)(newText, begin - 1)) {
-                begin--;
-            }
-            while (end < newText.length && !(0, format_1.isEOL)(newText, end)) {
-                end++;
-            }
-        }
-        const edits = (0, format_1.format)(newText, { offset: begin, length: end - begin }, { ...options.formattingOptions, keepLines: false });
-        // apply the formatting edits and track the begin and end offsets of the changes
-        for (let i = edits.length - 1; i >= 0; i--) {
-            const edit = edits[i];
-            newText = applyEdit(newText, edit);
-            begin = Math.min(begin, edit.offset);
-            end = Math.max(end, edit.offset + edit.length);
-            end += edit.content.length - edit.length;
-        }
-        // create a single edit with all changes
-        const editLength = text.length - (newText.length - end) - begin;
-        return [{ offset: begin, length: editLength, content: newText.substring(begin, end) }];
-    }
-    function applyEdit(text, edit) {
-        return text.substring(0, edit.offset) + edit.content + text.substring(edit.offset + edit.length);
-    }
-    exports.applyEdit = applyEdit;
-    function isWS(text, offset) {
-        return '\r\n \t'.indexOf(text.charAt(offset)) !== -1;
-    }
-    exports.isWS = isWS;
-});