@maroonedog/luq 0.1.2-alpha → 2.1.0

package/dist/json-schema/unsupported-keyword-error.js

@@ -0,0 +1,24 @@
+"use strict";
+// ===========================================================================
+// L8  src/json-schema/unsupported-keyword-error.ts
+//
+// 1.x's answer to a keyword it could not honour was to store it in a DSL field
+// and never read it again: `enum`, `contains`, `not`, `if`/`then`/`else`,
+// `patternProperties` and five more all looked supported and did nothing. A
+// validator that silently drops a constraint is worse than one that refuses
+// the schema, so the refusal is a typed error carrying the keyword, the reason
+// the table gives, and — when the reason is a missing plugin — its name.
+// ===========================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnsupportedKeywordError = void 0;
+class UnsupportedKeywordError extends Error {
+    constructor(keyword, reason) {
+        super(`JSON Schema keyword "${keyword}" is not supported: ${reason}`);
+        this.name = "UnsupportedKeywordError";
+        this.keyword = keyword;
+        this.reason = reason;
+        // Without this, `instanceof` fails when the package is compiled to ES5.
+        Object.setPrototypeOf(this, UnsupportedKeywordError.prototype);
+    }
+}
+exports.UnsupportedKeywordError = UnsupportedKeywordError;

package/dist/json-schema/unsupported-keyword-error.mjs

@@ -0,0 +1,20 @@
+// ===========================================================================
+// L8  src/json-schema/unsupported-keyword-error.ts
+//
+// 1.x's answer to a keyword it could not honour was to store it in a DSL field
+// and never read it again: `enum`, `contains`, `not`, `if`/`then`/`else`,
+// `patternProperties` and five more all looked supported and did nothing. A
+// validator that silently drops a constraint is worse than one that refuses
+// the schema, so the refusal is a typed error carrying the keyword, the reason
+// the table gives, and — when the reason is a missing plugin — its name.
+// ===========================================================================
+export class UnsupportedKeywordError extends Error {
+    constructor(keyword, reason) {
+        super(`JSON Schema keyword "${keyword}" is not supported: ${reason}`);
+        this.name = "UnsupportedKeywordError";
+        this.keyword = keyword;
+        this.reason = reason;
+        // Without this, `instanceof` fails when the package is compiled to ES5.
+        Object.setPrototypeOf(this, UnsupportedKeywordError.prototype);
+    }
+}

package/dist/json-schema/uri-reference.d.ts

@@ -0,0 +1,29 @@
+/** A URI with its fragment split off. `resource` is what identifies a document. */
+export interface SplitUri {
+    readonly resource: string;
+    /** Without the leading "#". Empty when the URI carries no fragment. */
+    readonly fragment: string;
+}
+export declare function splitUri(uri: string): SplitUri;
+/**
+ * `reference` resolved against `base`, both as written in the document.
+ *
+ * A base that is not itself absolute cannot resolve anything — that is the
+ * document that declared no `$id`, and it is the common case — so the
+ * reference is returned unchanged rather than guessed at. Callers then look
+ * the reference up verbatim, which is exactly what a local `#/...` pointer
+ * needs.
+ */
+export declare function resolveUriReference(base: string, reference: string): string;
+/** The same normalisation resolution applies, for a URI used as a KEY. */
+export declare function normalizeUri(uri: string): string;
+/**
+ * The base URI in force inside a node that declares `$id`.
+ *
+ * `$id: "#name"` is an ANCHOR, not a base: §8.2.3 gives it a plain-name
+ * fragment, and the base stays whatever it was. Treating it as a base would
+ * silently move every `$ref` written next to it.
+ */
+export declare function nextBaseUri(base: string, id: string | undefined): string;
+/** The anchor `$id` declares, if it declares one: `"#name"` -> `"name"`. */
+export declare function readAnchor(id: string | undefined): string | undefined;

package/dist/json-schema/uri-reference.js

@@ -0,0 +1,118 @@
+"use strict";
+// ===========================================================================
+// L8  src/json-schema/uri-reference.ts — `$id` と `$ref` の URI 演算。
+//
+// Draft-07 §8.2 の `$id` はベース URI を立て、`$ref` はその上で解決される。
+// つまり `$ref` は「文書内のポインタ」ではなく **URI 参照** であり、
+// 同じ文字列でも、どの `$id` の下に書かれたかで別の場所を指す。
+//
+// 解決は WHATWG URL に任せる。RFC 3986 §5.3 を手で書き直しても、
+// パーセント符号化・ドットセグメント・スキーム相対 (`//host/x`) の三つで
+// 必ずずれる — そして URL はブラウザにも Node にもある標準グローバルで、
+// eval も new Function も使わない (check:no-dynamic-code が見ている)。
+//
+// ネットワークには**触れない**。ここにあるのは文字列演算だけで、
+// 解決した URI をどう手に入れるかは呼び出し側の責任である
+// (schema-registry.ts の externalDocuments)。スキーマが書いた URI で
+// このプロセスがソケットを開くことは無い。
+// ===========================================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitUri = splitUri;
+exports.resolveUriReference = resolveUriReference;
+exports.normalizeUri = normalizeUri;
+exports.nextBaseUri = nextBaseUri;
+exports.readAnchor = readAnchor;
+function splitUri(uri) {
+    const hash = uri.indexOf("#");
+    if (hash < 0)
+        return { resource: uri, fragment: "" };
+    return { resource: uri.slice(0, hash), fragment: uri.slice(hash + 1) };
+}
+// RFC 3986 §3.1: scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) ":".
+// Scanned by code point rather than matched by a regex, because
+// test/unit/json-schema/core/format-map.test.ts forbids a character class
+// anywhere in this layer — 1.x grew a second and a third format table that
+// way, and the rule that prevents it is worth more than the two lines it costs.
+const COLON = 58;
+const PLUS = 43;
+const HYPHEN = 45;
+const DOT = 46;
+function isLetter(code) {
+    return (code > 64 && code < 91) || (code > 96 && code < 123);
+}
+function isDigit(code) {
+    return code > 47 && code < 58;
+}
+function isSchemeChar(code) {
+    return (isLetter(code) ||
+        isDigit(code) ||
+        code === PLUS ||
+        code === HYPHEN ||
+        code === DOT);
+}
+/** True when the reference names its own scheme, so no base is needed. */
+function isAbsolute(reference) {
+    if (reference.length === 0 || !isLetter(reference.charCodeAt(0))) {
+        return false;
+    }
+    for (let index = 1; index < reference.length; index += 1) {
+        const code = reference.charCodeAt(index);
+        if (code === COLON)
+            return true;
+        if (!isSchemeChar(code))
+            return false;
+    }
+    return false;
+}
+/**
+ * `reference` resolved against `base`, both as written in the document.
+ *
+ * A base that is not itself absolute cannot resolve anything — that is the
+ * document that declared no `$id`, and it is the common case — so the
+ * reference is returned unchanged rather than guessed at. Callers then look
+ * the reference up verbatim, which is exactly what a local `#/...` pointer
+ * needs.
+ */
+function resolveUriReference(base, reference) {
+    if (base === "" || !isAbsolute(base)) {
+        return isAbsolute(reference) ? normalizeUri(reference) : reference;
+    }
+    try {
+        return new URL(reference, base).href;
+    }
+    catch {
+        return reference;
+    }
+}
+/** The same normalisation resolution applies, for a URI used as a KEY. */
+function normalizeUri(uri) {
+    if (!isAbsolute(uri))
+        return uri;
+    try {
+        return new URL(uri).href;
+    }
+    catch {
+        return uri;
+    }
+}
+/**
+ * The base URI in force inside a node that declares `$id`.
+ *
+ * `$id: "#name"` is an ANCHOR, not a base: §8.2.3 gives it a plain-name
+ * fragment, and the base stays whatever it was. Treating it as a base would
+ * silently move every `$ref` written next to it.
+ */
+function nextBaseUri(base, id) {
+    if (id === undefined || id === "" || id.startsWith("#"))
+        return base;
+    return resolveUriReference(base, id);
+}
+/** The anchor `$id` declares, if it declares one: `"#name"` -> `"name"`. */
+function readAnchor(id) {
+    if (id === undefined || !id.startsWith("#") || id.length === 1) {
+        return undefined;
+    }
+    const anchor = id.slice(1);
+    // A pointer fragment is not an anchor; `#/a/b` names a location.
+    return anchor.startsWith("/") ? undefined : anchor;
+}

package/dist/json-schema/uri-reference.mjs

@@ -0,0 +1,111 @@
+// ===========================================================================
+// L8  src/json-schema/uri-reference.ts — `$id` と `$ref` の URI 演算。
+//
+// Draft-07 §8.2 の `$id` はベース URI を立て、`$ref` はその上で解決される。
+// つまり `$ref` は「文書内のポインタ」ではなく **URI 参照** であり、
+// 同じ文字列でも、どの `$id` の下に書かれたかで別の場所を指す。
+//
+// 解決は WHATWG URL に任せる。RFC 3986 §5.3 を手で書き直しても、
+// パーセント符号化・ドットセグメント・スキーム相対 (`//host/x`) の三つで
+// 必ずずれる — そして URL はブラウザにも Node にもある標準グローバルで、
+// eval も new Function も使わない (check:no-dynamic-code が見ている)。
+//
+// ネットワークには**触れない**。ここにあるのは文字列演算だけで、
+// 解決した URI をどう手に入れるかは呼び出し側の責任である
+// (schema-registry.ts の externalDocuments)。スキーマが書いた URI で
+// このプロセスがソケットを開くことは無い。
+// ===========================================================================
+export function splitUri(uri) {
+    const hash = uri.indexOf("#");
+    if (hash < 0)
+        return { resource: uri, fragment: "" };
+    return { resource: uri.slice(0, hash), fragment: uri.slice(hash + 1) };
+}
+// RFC 3986 §3.1: scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." ) ":".
+// Scanned by code point rather than matched by a regex, because
+// test/unit/json-schema/core/format-map.test.ts forbids a character class
+// anywhere in this layer — 1.x grew a second and a third format table that
+// way, and the rule that prevents it is worth more than the two lines it costs.
+const COLON = 58;
+const PLUS = 43;
+const HYPHEN = 45;
+const DOT = 46;
+function isLetter(code) {
+    return (code > 64 && code < 91) || (code > 96 && code < 123);
+}
+function isDigit(code) {
+    return code > 47 && code < 58;
+}
+function isSchemeChar(code) {
+    return (isLetter(code) ||
+        isDigit(code) ||
+        code === PLUS ||
+        code === HYPHEN ||
+        code === DOT);
+}
+/** True when the reference names its own scheme, so no base is needed. */
+function isAbsolute(reference) {
+    if (reference.length === 0 || !isLetter(reference.charCodeAt(0))) {
+        return false;
+    }
+    for (let index = 1; index < reference.length; index += 1) {
+        const code = reference.charCodeAt(index);
+        if (code === COLON)
+            return true;
+        if (!isSchemeChar(code))
+            return false;
+    }
+    return false;
+}
+/**
+ * `reference` resolved against `base`, both as written in the document.
+ *
+ * A base that is not itself absolute cannot resolve anything — that is the
+ * document that declared no `$id`, and it is the common case — so the
+ * reference is returned unchanged rather than guessed at. Callers then look
+ * the reference up verbatim, which is exactly what a local `#/...` pointer
+ * needs.
+ */
+export function resolveUriReference(base, reference) {
+    if (base === "" || !isAbsolute(base)) {
+        return isAbsolute(reference) ? normalizeUri(reference) : reference;
+    }
+    try {
+        return new URL(reference, base).href;
+    }
+    catch {
+        return reference;
+    }
+}
+/** The same normalisation resolution applies, for a URI used as a KEY. */
+export function normalizeUri(uri) {
+    if (!isAbsolute(uri))
+        return uri;
+    try {
+        return new URL(uri).href;
+    }
+    catch {
+        return uri;
+    }
+}
+/**
+ * The base URI in force inside a node that declares `$id`.
+ *
+ * `$id: "#name"` is an ANCHOR, not a base: §8.2.3 gives it a plain-name
+ * fragment, and the base stays whatever it was. Treating it as a base would
+ * silently move every `$ref` written next to it.
+ */
+export function nextBaseUri(base, id) {
+    if (id === undefined || id === "" || id.startsWith("#"))
+        return base;
+    return resolveUriReference(base, id);
+}
+/** The anchor `$id` declares, if it declares one: `"#name"` -> `"name"`. */
+export function readAnchor(id) {
+    if (id === undefined || !id.startsWith("#") || id.length === 1) {
+        return undefined;
+    }
+    const anchor = id.slice(1);
+    // A pointer fragment is not an anchor; `#/a/b` names a location.
+    return anchor.startsWith("/") ? undefined : anchor;
+}

package/dist/path/create-array-reader.d.ts

@@ -0,0 +1,13 @@
+import type { PathSegment } from "./path-segment.types";
+export type ArrayReader = (subject: unknown) => readonly unknown[] | null;
+/**
+ * null means "there is no array here", which the runner treats as "element
+ * rules are vacuous" — the must-preserve contract that a non-array at an `[*]`
+ * path produces no issue from the element rule. Asserting that the container
+ * IS an array is a separate, declared rule on the container path.
+ *
+ * An empty array is an array: it reads back as `[]`, and the element loop then
+ * runs zero times. That distinction is the whole reason this returns
+ * `readonly unknown[] | null` and not `readonly unknown[]`.
+ */
+export declare function createArrayReader(template: readonly PathSegment[]): ArrayReader;

package/dist/path/create-array-reader.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createArrayReader = createArrayReader;
+const create_value_reader_1 = require("./create-value-reader");
+const types_1 = require("../types");
+/**
+ * null means "there is no array here", which the runner treats as "element
+ * rules are vacuous" — the must-preserve contract that a non-array at an `[*]`
+ * path produces no issue from the element rule. Asserting that the container
+ * IS an array is a separate, declared rule on the container path.
+ *
+ * An empty array is an array: it reads back as `[]`, and the element loop then
+ * runs zero times. That distinction is the whole reason this returns
+ * `readonly unknown[] | null` and not `readonly unknown[]`.
+ */
+function createArrayReader(template) {
+    const read = (0, create_value_reader_1.createValueReader)(template);
+    return (subject) => {
+        const value = read(subject);
+        return (0, types_1.isArray)(value) ? value : null;
+    };
+}

package/dist/path/create-array-reader.mjs

@@ -0,0 +1,19 @@
+import { createValueReader } from "./create-value-reader.mjs";
+import { isArray } from "../types/index.mjs";
+/**
+ * null means "there is no array here", which the runner treats as "element
+ * rules are vacuous" — the must-preserve contract that a non-array at an `[*]`
+ * path produces no issue from the element rule. Asserting that the container
+ * IS an array is a separate, declared rule on the container path.
+ *
+ * An empty array is an array: it reads back as `[]`, and the element loop then
+ * runs zero times. That distinction is the whole reason this returns
+ * `readonly unknown[] | null` and not `readonly unknown[]`.
+ */
+export function createArrayReader(template) {
+    const read = createValueReader(template);
+    return (subject) => {
+        const value = read(subject);
+        return isArray(value) ? value : null;
+    };
+}

package/dist/path/create-value-reader.d.ts

@@ -0,0 +1,26 @@
+import type { PathSegment } from "./path-segment.types";
+export type ValueReader = (subject: unknown) => unknown;
+/** True for arrays too: both are indexable by a string key. */
+export declare function isIndexableObject(value: unknown): value is Record<string, unknown>;
+/**
+ * Own properties only. `in` and plain member access walk the prototype chain,
+ * which is how the legacy tree reported `toString` as a present field. A
+ * primitive intermediate does NOT descend (`{user:"John"}` at `user.name` is
+ * undefined, not `"John".name`), and an array hole is absent rather than
+ * undefined-valued — the same answer either way, reached honestly.
+ */
+export declare function readOwnProperty(subject: unknown, key: string): unknown;
+/**
+ * Validates a template and flattens it to plain keys. Shared with the writer
+ * so the two directions cannot disagree about what a template may contain.
+ *
+ * A `[*]` segment is rejected: a wildcard names many values, and this reader
+ * has one return value. The array runner splits a wildcard template into an
+ * array node plus an element template before it ever gets here.
+ */
+export declare function collectKeySegments(template: readonly PathSegment[]): readonly string[];
+/**
+ * An empty template is the identity reader: the element of `items[*]` is
+ * declared relative to itself, and that is a real compiled field.
+ */
+export declare function createValueReader(template: readonly PathSegment[]): ValueReader;

package/dist/path/create-value-reader.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isIndexableObject = isIndexableObject;
+exports.readOwnProperty = readOwnProperty;
+exports.collectKeySegments = collectKeySegments;
+exports.createValueReader = createValueReader;
+const reserved_segment_1 = require("./reserved-segment");
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+/** True for arrays too: both are indexable by a string key. */
+function isIndexableObject(value) {
+    return typeof value === "object" && value !== null;
+}
+/**
+ * Own properties only. `in` and plain member access walk the prototype chain,
+ * which is how the legacy tree reported `toString` as a present field. A
+ * primitive intermediate does NOT descend (`{user:"John"}` at `user.name` is
+ * undefined, not `"John".name`), and an array hole is absent rather than
+ * undefined-valued — the same answer either way, reached honestly.
+ */
+function readOwnProperty(subject, key) {
+    if (!isIndexableObject(subject))
+        return undefined;
+    return hasOwnProperty.call(subject, key) ? subject[key] : undefined;
+}
+/**
+ * Validates a template and flattens it to plain keys. Shared with the writer
+ * so the two directions cannot disagree about what a template may contain.
+ *
+ * A `[*]` segment is rejected: a wildcard names many values, and this reader
+ * has one return value. The array runner splits a wildcard template into an
+ * array node plus an element template before it ever gets here.
+ */
+function collectKeySegments(template) {
+    const rendered = describeTemplate(template);
+    const keys = [];
+    for (const segment of template) {
+        if (segment.kind === "each") {
+            throw new reserved_segment_1.PathSyntaxError(rendered, "a single-value template must not contain a wildcard segment");
+        }
+        (0, reserved_segment_1.assertDeclarableKey)(segment.key, rendered);
+        keys.push(segment.key);
+    }
+    return keys;
+}
+function describeTemplate(template) {
+    return template
+        .map((segment) => (segment.kind === "each" ? "[*]" : segment.key))
+        .join(".");
+}
+/**
+ * An empty template is the identity reader: the element of `items[*]` is
+ * declared relative to itself, and that is a real compiled field.
+ */
+function createValueReader(template) {
+    const keys = collectKeySegments(template);
+    const only = keys[0];
+    if (keys.length === 0)
+        return (subject) => subject;
+    if (keys.length === 1 && only !== undefined) {
+        return (subject) => readOwnProperty(subject, only);
+    }
+    return (subject) => {
+        let current = subject;
+        for (const key of keys) {
+            current = readOwnProperty(current, key);
+            if (current === undefined)
+                return undefined;
+        }
+        return current;
+    };
+}

package/dist/path/create-value-reader.mjs

@@ -0,0 +1,65 @@
+import { PathSyntaxError, assertDeclarableKey } from "./reserved-segment.mjs";
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+/** True for arrays too: both are indexable by a string key. */
+export function isIndexableObject(value) {
+    return typeof value === "object" && value !== null;
+}
+/**
+ * Own properties only. `in` and plain member access walk the prototype chain,
+ * which is how the legacy tree reported `toString` as a present field. A
+ * primitive intermediate does NOT descend (`{user:"John"}` at `user.name` is
+ * undefined, not `"John".name`), and an array hole is absent rather than
+ * undefined-valued — the same answer either way, reached honestly.
+ */
+export function readOwnProperty(subject, key) {
+    if (!isIndexableObject(subject))
+        return undefined;
+    return hasOwnProperty.call(subject, key) ? subject[key] : undefined;
+}
+/**
+ * Validates a template and flattens it to plain keys. Shared with the writer
+ * so the two directions cannot disagree about what a template may contain.
+ *
+ * A `[*]` segment is rejected: a wildcard names many values, and this reader
+ * has one return value. The array runner splits a wildcard template into an
+ * array node plus an element template before it ever gets here.
+ */
+export function collectKeySegments(template) {
+    const rendered = describeTemplate(template);
+    const keys = [];
+    for (const segment of template) {
+        if (segment.kind === "each") {
+            throw new PathSyntaxError(rendered, "a single-value template must not contain a wildcard segment");
+        }
+        assertDeclarableKey(segment.key, rendered);
+        keys.push(segment.key);
+    }
+    return keys;
+}
+function describeTemplate(template) {
+    return template
+        .map((segment) => (segment.kind === "each" ? "[*]" : segment.key))
+        .join(".");
+}
+/**
+ * An empty template is the identity reader: the element of `items[*]` is
+ * declared relative to itself, and that is a real compiled field.
+ */
+export function createValueReader(template) {
+    const keys = collectKeySegments(template);
+    const only = keys[0];
+    if (keys.length === 0)
+        return (subject) => subject;
+    if (keys.length === 1 && only !== undefined) {
+        return (subject) => readOwnProperty(subject, only);
+    }
+    return (subject) => {
+        let current = subject;
+        for (const key of keys) {
+            current = readOwnProperty(current, key);
+            if (current === undefined)
+                return undefined;
+        }
+        return current;
+    };
+}

package/dist/path/create-value-writer.d.ts

@@ -0,0 +1,5 @@
+import type { PathSegment } from "./path-segment.types";
+/** Returns the new root. It is NOT `void`: a copy-on-write write cannot report
+ *  its result through the argument it refused to mutate. */
+export type ValueWriter = (subject: unknown, value: unknown) => unknown;
+export declare function createValueWriter(template: readonly PathSegment[]): ValueWriter;

package/dist/path/create-value-writer.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createValueWriter = createValueWriter;
+const create_value_reader_1 = require("./create-value-reader");
+const types_1 = require("../types");
+function createValueWriter(template) {
+    const keys = (0, create_value_reader_1.collectKeySegments)(template);
+    if (keys.length === 0)
+        return (_subject, value) => value;
+    return (subject, value) => writeInto(subject, keys, 0, value);
+}
+function writeInto(container, keys, depth, value) {
+    const key = keys[depth];
+    if (key === undefined)
+        return value;
+    if (container === null || container === undefined) {
+        return vivify(key, writeInto(undefined, keys, depth + 1, value));
+    }
+    if (!(0, create_value_reader_1.isIndexableObject)(container))
+        return container;
+    const child = (0, create_value_reader_1.readOwnProperty)(container, key);
+    const written = writeInto(child, keys, depth + 1, value);
+    if (written === child)
+        return container;
+    return copyWith(container, key, written);
+}
+/**
+ * Auto-vivification, restricted to the one case the legacy rule got wrong:
+ * only a missing or null intermediate is created. A present primitive is left
+ * exactly as it is (the `if (!isIndexableObject) return container` above), so
+ * writing `a.b` into `{a: 0}` destroys nothing and returns the original root
+ * by identity.
+ *
+ * The container created is always a plain object. A numeric segment does not
+ * conjure an array — the declaration grammar cannot express `items[0]`, so a
+ * numeric key here is a Record key.
+ */
+/**
+ * キーを own プロパティとして置く。**代入演算子を使わない。**
+ *
+ * `copy[key] = value` は key が "__proto__" のとき Object.prototype の
+ * アクセサ (setter) を呼び、own プロパティを作る代わりにプロトタイプを
+ * 差し替えてしまう。defineProperty はアクセサを見ずに own プロパティを
+ * 定義するので、"__proto__" という名前のプロパティを安全に持てる。
+ *
+ * "constructor" と "prototype" は Object.prototype 上でデータプロパティ
+ * なので代入でも own プロパティになるが、キーごとに分岐すると分岐のほうを
+ * 間違えるので一律にこちらを通す。
+ *
+ * これが「宣言パスに __proto__ を書けるようにする」の前提。書き込みが安全に
+ * なったので、パス文法の側で拒否する必要が無くなった (reserved-segment.ts)。
+ */
+function putOwnProperty(target, key, value) {
+    Object.defineProperty(target, key, {
+        value,
+        writable: true,
+        enumerable: true,
+        configurable: true,
+    });
+}
+function vivify(key, written) {
+    const created = {};
+    putOwnProperty(created, key, written);
+    return created;
+}
+function copyWith(container, key, value) {
+    if ((0, types_1.isArray)(container)) {
+        const index = Number(key);
+        if (!Number.isInteger(index) || index < 0)
+            return container;
+        const copy = container.slice();
+        copy[index] = value;
+        return copy;
+    }
+    // スプレッドは own の列挙可能プロパティを CreateDataProperty で写すので、
+    // ここでは setter は動かない。危ないのは下の代入だけ。
+    const copy = { ...container };
+    putOwnProperty(copy, key, value);
+    return copy;
+}